﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SG.Domain;
using System.Collections;
using SG.Logic.Stock;

namespace SG.Logic
{
    public class ExpArticulo:ContextManager
    {
        #region Constructor
        public ExpArticulo():base() { 
        
        }
        public ExpArticulo(SGEntities cont)
            : base(cont)
        { 
        
        }

        #endregion 
        public IList<Articulo> GetAllArticulo() {
            return Context.Articulo.ToList();
        }
        public void SaveArticulo(Articulo entity) {
           

            Context.AddToArticulo(entity);
          
            Context.SaveChanges();
        }
        public void SavePolitica(Politica entity)
        {

            Context.AddToPolitica(entity);

            Context.SaveChanges();
        }
        public void SaveOrUpdatePolitica(Politica entity)
        {
            Politica entityToSave = new Politica();
            if (entity.Id > 0)// si es una actualizacion
            {
                entityToSave = Context.Politica.Where(f => f.Id == entity.Id).First();
            }
            else
            {//si es una creación
                
                Context.AddToPolitica(entityToSave);
            }
            entityToSave.Nombre = entity.Nombre;

                   Context.SaveChanges();
        }
        public void SaveOrUpdateArticulo(Articulo entity) {
            bool actualizar = false;
            int pos = 0;
            Articulo entityToSave = new Articulo();
            if (entity.Id > 0)// si es una actualizacion
            {
                entityToSave = Context.Articulo.Where(f => f.Id == entity.Id).First();
            }
            else
            {//si es una creación
                entityToSave.FechaAlta = DateTime.Now;
                entityToSave.Estado = "No asignado";

                //obtiene el número siguiente
                if (Context.Articulo.Count() > 0)
                    entityToSave.NumeroArticulo = Context.Articulo.Max(f => f.NumeroArticulo) + 1;
                else
                    entityToSave.NumeroArticulo = 1;


                Context.AddToArticulo(entityToSave);
            }
                entityToSave.Nombre = entity.Nombre;

                if (entity.Id == 0 || entityToSave.idSuavizamiento != entity.idSuavizamiento)
                {
                    //for (int i = 0; i < entityToSave.Periodo.Count; i++)
                    //{
                    //    Context.Error.DeleteObject(entityToSave.Periodo.ToList()[i].Error);                    
                    //    i++;
                    //}

                    //for (int i = 0; i < entityToSave.Periodo.Count; i++)
                    //{
                    //    entityToSave.Periodo.Remove(entityToSave.Periodo.ToList()[i]);
                    //    i++;
                    //}


                    //for (int i = 0; i < entityToSave.Indice.Count; i++)
                    //{
                    //    entityToSave.Indice.Remove(entityToSave.Indice.ToList()[i]);
                    //    i++;
                    //}
                    do
                    {
                        entity.Periodo.ToList()[0].NumeroPeriodo = ++pos;
                        entityToSave.Periodo.Add(entity.Periodo.ToList()[0]);
                    } while (entity.Periodo.Count > 0);            

                }

                //do
                //{
                //    entity.Periodo.ToList()[0].NumeroPeriodo = ++pos;
                //    entityToSave.Periodo.Add(entity.Periodo.ToList()[0]);
                //} while (entity.Periodo.Count > 0);            


            pos = 0;
            while (entity.Indice.Count > 0)
            {
                entityToSave.Indice.Add(entity.Indice.ToList()[0]);
            } ;

            entityToSave.Descripcion = entity.Descripcion;
            entityToSave.idSuavizamiento = entity.idSuavizamiento;            
            entityToSave.CantEstaciones = entity.CantEstaciones;
            entityToSave.CantDias = entity.CantDias;
            entityToSave.Stock = entity.Stock;
            entityToSave.Alpha = entity.Alpha;
            entityToSave.Beta = entity.Beta;
            entityToSave.Gamma = entity.Gamma;
            entityToSave.UltimoPrecio = entity.UltimoPrecio;
            entityToSave.DemandaAnual = entity.DemandaAnual;
            entityToSave.IdNivelServicio = entity.IdNivelServicio;
            entityToSave.TasaAlmacenamiento = entity.TasaAlmacenamiento;

            if (entityToSave.TasaAlmacenamiento != entity.TasaAlmacenamiento)
            {
                entityToSave.TasaAlmacenamiento = entity.TasaAlmacenamiento;
                actualizar = true;
            }
            
            entityToSave.LoteOptimo = entity.LoteOptimo;

            if (entityToSave.IdCategoria != entity.IdCategoria)
            {
                entityToSave.IdCategoria = entity.IdCategoria;
                actualizar = true;
            }
            entityToSave.IdCategoria = entity.IdCategoria;
            
            entityToSave.UltimaActualizacion = DateTime.Now;

            if (entityToSave.IdPolitica != entity.IdPolitica)
            {
                entityToSave.IdPolitica = entity.IdPolitica;
                actualizar = true;
            }
            if (entityToSave.Estado == "Asignado" && actualizar)
            {
                ExpPolitica expP = new ExpPolitica(base.Context);
                
                actualizar = false;
                expP.CalcularPolitica(entityToSave);                
            }            
            Context.SaveChanges();
        }
        public Articulo GetArticulo(int id) {
            return Context.Articulo.Where(f => f.Id == id).FirstOrDefault();
        }
        public Politica GetPolitica(int id)
        {
            return Context.Politica.Where(f => f.Id == id).FirstOrDefault();
        }
        public void DeleteArticulo(int id) {
            Context.DeleteObject(Context.Articulo.Where(f => f.Id == id).First());
            Context.SaveChanges();
        
        }
        public List<Categoria> GetAllCategoria()
        {
            return Context.Categoria.ToList();
        }

        public List<Politica> GetAllPolitica()
        {
            return Context.Politica.ToList();
        }
        public List<Suavizamiento> GetAllSuavizamiento()
        {
            return Context.Suavizamiento.ToList();
        }
        public List<NivelServicio> GetAllNivelServicio()
        {
            return Context.NivelServicio.ToList();
        }
        public void SaveCategoria(Categoria entity)
        {
            Context.AddToCategoria(entity);
            Context.SaveChanges();
        }
        public void SaveOrUpdateCategoria(Categoria entity)
        {
            Categoria entityToSave = new Categoria();
            if (entity.Id > 0)// si es una actualizacion
            {
                entityToSave = Context.Categoria.Where(f => f.Id == entity.Id).First();
            }
            else
            {//si es una creación

                Context.AddToCategoria(entityToSave);
            }

            
            entityToSave.Nombre = entity.Nombre;
            entityToSave.LimiteSuperior = entity.LimiteSuperior;
            entityToSave.LimiteInferior = entity.LimiteInferior;
            entityToSave.AgotamientoAnualPermitido = entity.AgotamientoAnualPermitido;


            Context.SaveChanges();
        }
        public void UpdateCategoria(Categoria entity)
        {
            Categoria entityUpdate = Context.Categoria.Where(f => f.Id == entity.Id).First();
            entityUpdate.AgotamientoAnualPermitido = entity.AgotamientoAnualPermitido;
            entityUpdate.Id = entity.Id;
            entityUpdate.LimiteInferior = entity.LimiteInferior;
            entityUpdate.LimiteSuperior = entity.LimiteSuperior;
            entityUpdate.Nombre = entity.Nombre;
            Context.SaveChanges();
        }
        public void UpdatePolitica(Politica entity)
        {
            Politica entityUpdate = Context.Politica.Where(f => f.Id == entity.Id).First();
            entityUpdate.Id = entity.Id;
            entityUpdate.Nombre = entity.Nombre;
            Context.SaveChanges();
        }

        public Categoria GetCategoria(int id)
        {
            
            return Context.Categoria.Where(f => f.Id == id).FirstOrDefault();
        }

        public void DeleteCategoria(int id)
        {
            Categoria c = Context.Categoria.Where(f => f.Id == id).First();
            if (c.Articulo.Count > 0) throw new Exception("La categoría " +c.Nombre + " está en uso");
            Context.DeleteObject(c);
            Context.SaveChanges();

        }
        public void DeletePolitica(int id)
        {
            Politica p = Context.Politica.Where(f => f.Id == id).First();
            if (p.Articulo.Count>0) throw new Exception("La política "+p.Nombre+" está en uso");
            Context.DeleteObject(p);
            Context.SaveChanges();

        }
        public OrdenCompra GetOrdenCompra(int id)
        {
            return Context.OrdenCompra.Where(f => f.Id == id).FirstOrDefault();
        }
        public List<DetalleOrdenDeCompra> GetAllDetalleOrdenCompra(int idOrdenCompra)
        {
            return Context.DetalleOrdenDeCompra.Where(f => f.IdOrdencompra == idOrdenCompra).ToList();
        }
        public IList<OrdenCompra> GetAllOrdenCompra()
        {
            return Context.OrdenCompra.ToList();
        }
        public void SaveOrdenCompra(OrdenCompra entity)
        {
            entity.FechaEmision = DateTime.Now;
            if (Context.OrdenCompra.Count() > 0)
                entity.NumeroOrden = Context.OrdenCompra.Max(f => f.NumeroOrden) + 1;
            else
                entity.NumeroOrden = 1;
            
            Context.AddToOrdenCompra(entity);

            Context.SaveChanges();
        }

        public void ConfirmOrdenCompra(int id)
        {
            OrdenCompra entity = Context.OrdenCompra.Where(f => f.Id == id).First();

            if (entity.Estado == "Emitida")
            {
                foreach (var item in entity.DetalleOrdenDeCompra)
                {
                    Articulo articulo = Context.Articulo.Single(f => f.Id == item.IdArticulo);
                    articulo.Stock += item.Cantidad;
                    articulo.StockARecepcionar -= item.Cantidad;
                    articulo.UltimaActualizacion = DateTime.Now;
                }
                entity.Estado = "Confirmada";
                entity.FechaEntrega = DateTime.Now;
                
                Proveedor proveedor = Context.Proveedor.Where(f => f.Id == entity.IdProveedor).First();
                proveedor.FechaUltimaVisita = DateTime.Now;
                Context.SaveChanges();
            }
            else if (entity.Estado == "Recibida")
                throw new Exception("La orden de compra ya fue recibida." );
            else if (entity.Estado == "Anulada")
                throw new Exception("La orden de compra no se puede recibir porque ya fue anulada.");
            else if (entity.Estado == "Generada")
                throw new Exception("La orden de compra debe ser confirmada primero.");
            else if (entity.Estado == "Confirmada")
                throw new Exception("La orden de compra ya fue confirmada.");

        }

        public void GenerateOrdenCompra(int id)
        {
            OrdenCompra entity = Context.OrdenCompra.Where(f => f.Id == id).First();

            if (entity.Estado == "Generada")
            {
                entity.Estado = "Emitida";
                entity.FechaEmision = DateTime.Now;
                foreach (var item in entity.DetalleOrdenDeCompra)
                {
                    Articulo articulo = Context.Articulo.Single(f => f.Id == item.IdArticulo);
                    articulo.StockARecepcionar += item.Cantidad;
                }
                Context.SaveChanges();
            }
            else if (entity.Estado == "Recibida")
                throw new Exception("La orden de compra ya fue recibida.");
            else if (entity.Estado == "Anulada")
                throw new Exception("La orden de compra no se puede generar porque ya fue anulada.");
            else if (entity.Estado == "Confirmada")
                throw new Exception("La orden de compra ya fue generada.");
            else if (entity.Estado == "Emitida")
                throw new Exception("La orden de compra ya fue emitida por lo tanto no se puede Generar.");
        }
        public void AnularOrdenCompra(int id)
        {
            OrdenCompra entity = Context.OrdenCompra.Where(f => f.Id == id).First();
            if (entity.Estado == "Emitida" || entity.Estado == "Generada")
             {               
                entity.Estado = "Anulada";
                foreach (var item in entity.DetalleOrdenDeCompra)
                {
                    Articulo articulo = Context.Articulo.Single(f => f.Id == item.IdArticulo);
                    articulo.StockARecepcionar -= item.Cantidad;
                }
                Context.SaveChanges();
             }
             else if (entity.Estado == "Recibida")
                 throw new Exception("La orden de compra no se puede anular porque ya fue recibida.");
             else if (entity.Estado == "Anulada")
                 throw new Exception("La orden de compra ya fue anulada.");
            else if (entity.Estado == "Confirmada")
                throw new Exception("La orden de compra ya fue confirmada no se puede anular.");
        }
        public IList<ArticuloProveedor> GetAllArticuloProveedor()
        {
            return Context.ArticuloProveedor.OrderBy(f=>f.Proveedor.Nombre).OrderBy(f=>f.Articulo.Nombre).ToList();
        }

        public IList<Articulo> GetAllArticuloDebajoPP()
        {
            return Context.Articulo.Where(f=>f.Stock < f.PuntoPedido).ToList();
        }

        public IList<DTOCurvaABC> GetAllArticuloCurvaABC()
        {
            float demandaAcumulada = 0;
            demandaAcumulada = Context.Articulo.Sum(f => f.DemandaAnual * f.UltimoPrecio + demandaAcumulada);
            IList<DTOCurvaABC> result = new List<DTOCurvaABC>();

            float davAcc = 0;
            string clase;
            float itemporc = 0;
            float itemporc1 = 0;
            itemporc = 100 / Context.Articulo.Count();
            itemporc1 = itemporc;
            foreach (Articulo item in Context.Articulo.OrderByDescending(f => f.DemandaAnual * f.UltimoPrecio))
            {
                if (((((item.DemandaAnual * item.UltimoPrecio) + davAcc) / demandaAcumulada) * 100) < 80)
                    clase = "A";
                else if (((((item.DemandaAnual * item.UltimoPrecio) + davAcc) / demandaAcumulada) * 100) > 90)
                    clase = "C";
                else
                    clase = "B";

                result.Add(new DTOCurvaABC()
                {
                    Nombre = item.Nombre,
                    NumeroArticulo = item.NumeroArticulo,
                    CostoUnitario = item.UltimoPrecio,
                    DemandaAnual = item.DemandaAnual,
                    DAV = item.DemandaAnual * item.UltimoPrecio,
                    DAVAcumulada = (item.DemandaAnual * item.UltimoPrecio) + davAcc,
                    PorcentajeCAP = (((item.DemandaAnual * item.UltimoPrecio) + davAcc) / demandaAcumulada) * 100,
                    PorcentajeItem = itemporc,
                    Clase = clase

                });
                davAcc += item.DemandaAnual * item.UltimoPrecio;
                itemporc += itemporc1;
            }

            return result;

        }

        public List<Periodo> GetAllPeriodoByIdArticulo(int idArticulo)
        {
            return Context.Articulo.Single(f => f.Id == idArticulo).Periodo.ToList();

        }

        public Periodo GetLastPeriodo(int idArticulo) {
            //return Context.Periodo.Where(f => f.IdArticulo == idArticulo && f.Actualizado > 0).FirstOrDefault();
            return Context.Periodo.Where(f => f.IdArticulo == idArticulo && f.Actualizado > 0).OrderByDescending(f => f.Fecha).FirstOrDefault();
        
        }

        public Periodo GetLastPeriodoParaPolitica(int idArticulo)
        {
            return Context.Periodo.Where(f => f.IdArticulo == idArticulo && f.Actualizado > 0).OrderByDescending(f => f.Fecha).FirstOrDefault();

        }

        public Error GetDetallesPeriodo(int idPeriodo)
        {
            return Context.Periodo.Single(f => f.Id == idPeriodo).Error;        

        }   

        public double PredecirPeriodo(int idArticulo, int numPeriodo)
        {
            int h;
            Exponencial exp;
            List<Periodo> periodos = Context.Periodo.Where(f => f.IdArticulo == idArticulo).ToList();
            Periodo ultimo = GetLastPeriodo(idArticulo);

            foreach (Periodo p in periodos)
            {
                if (numPeriodo == p.NumeroPeriodo && p.Actualizado == 0)
                {
                    return p.Prediccion;
                }
                else if (numPeriodo == p.NumeroPeriodo && p.Actualizado > 0)
                {
                    return -1;
                }
            }



            exp = FabricaExponencial.CrearExponencial(Context.Articulo.First(f => f.Id == idArticulo).idSuavizamiento);
            h = numPeriodo - ultimo.NumeroPeriodo;
            return exp.GenerarPrediccion(ultimo, h);
        }      



        private void GenerateIndices(Articulo art, List<Double> valorIndiceList, List<DateTime> fechaList)
        {
            Indice indice;

            for (int i = 0; i < valorIndiceList.Count(); i++)
            {
                indice = new Indice();
                indice.NumeroEstacion=i + 1;
                //indice.Articulo=art;
                
                indice.fechaInicio = fechaList[i];
                indice.Valor = valorIndiceList[i];
                indice.fueUsuado=0;
                art.Indice.Add(indice);
               // Context.Indice.AddObject(indice);
            }
            
        }

        private DateTime CalcularFecha(Periodo nuevo, Periodo ultimo)
        {
            //int h = nuevo.NumeroPeriodo - ultimo.NumeroPeriodo;
            //DateTime fecha = new DateTime(ultimo.Fecha.Ticks);
            //fecha = fecha.AddDays(ultimo.Fecha.Day + (ultimo.Articulo.CantDias * h));

            int h = nuevo.NumeroPeriodo - ultimo.NumeroPeriodo;
            DateTime fecha = new DateTime(ultimo.Fecha.Ticks);
            fecha = fecha.AddDays(ultimo.CantDias * h);

            return fecha;
        }

        private void GenerarPeriodo(Periodo anterior, Articulo articulo)
        {
            Exponencial exp;

            Periodo nuevo = new Periodo();
            Error error = new Error();

            nuevo.Articulo=anterior.Articulo;
            nuevo.NumeroPeriodo=anterior.NumeroPeriodo + 1;
            nuevo.Fecha=CalcularFecha(nuevo, anterior);
            nuevo.Actualizado=0;
            nuevo.CantDias=anterior.Articulo.CantDias;
            exp = FabricaExponencial.CrearExponencial(anterior.Articulo.idSuavizamiento);
            
            // Seba : 03/07. Si es Exponencial con tendencia resto el numero de periodo al anterior para obtener bien el h
            int h = nuevo.NumeroPeriodo;
            if (anterior.Articulo.idSuavizamiento == 2)
                h = h - anterior.NumeroPeriodo;
            
            
            nuevo.Prediccion=exp.GenerarPrediccion(anterior, h);
            nuevo.Error=error;
            articulo.Periodo.Add(nuevo);
            
        }

        private void CorregirIndices(Articulo art, List<Double> valoresIndices)
        {
            List<Indice> indices = art.Indice.ToList();

            for (int i = 0; i < valoresIndices.Count; i++)
            {
                if (valoresIndices[i] != indices[i].Valor)
                {
                    indices[i].Valor=valoresIndices.ToList()[i];
                    //todo: Fachada.getInstancia().modificar(indices.ToList()[i]);
                }
            }
        }

        private void EliminarIndices(Articulo art)
        {
            List<Indice> indices = art.Indice.ToList();

            for (int i = 0; i < indices.Count; i++)
            {
                art.Indice.Remove(indices[i]);
                
                //todo: Fachada.getInstancia().eliminar(indices.elementAt(i));
            }
        }





        //Estacionalidad
        public void IniciarPeriodo(Articulo art, double promedio, List<Double> valoresIndices, List<DateTime> fechas, double errorPromedio, double MSEn, double desviacionEstandar)
        {
            
            if (promedio >= 0)
            {
                Periodo periodo = new Periodo();
                periodo.NumeroPeriodo=1;
                periodo.Articulo=art;
                periodo.Promedio=promedio;
                periodo.Actualizado=1;
                periodo.Prediccion=valoresIndices.Last()*promedio;                  
                periodo.Demanda = 0;
                periodo.CantDias = art.CantDias;
                DateTime fecha = new DateTime(fechas[0].Ticks);
                fecha=fecha.AddDays( - art.CantDias);
                periodo.Fecha=fecha;    //el periodo creado registra datos histÃ³ricos por lo que su fecha de creacion es anterior a la del 1Âº periodo real
                periodo.Error = new Error() { ErrorPromedio = errorPromedio, MSEn = MSEn, DesviacionEstandar = desviacionEstandar };
                
                GenerateIndices(art, valoresIndices, fechas);
                GenerarPeriodo(periodo,art);
            }
            else
            {
                if (art.Indice.Count == valoresIndices.Count && art.Indice.First().fechaInicio.Day == fechas[0].Day
                                                                    && art.Indice.First().fechaInicio.Month == fechas.First().Month)
                {
                    CorregirIndices(art, valoresIndices);
                }
                else
                {
                    EliminarIndices(art);
                    GenerateIndices(art, valoresIndices, fechas);
                }
            }

            //todo:Fachada.getInstancia().cerrarSesion();
        }
















        //Simple
        public void IniciarPeriodo(Articulo art, double promedio,double errorPromedio, double MSEn, double desviacionEstandar)
        {
            Periodo periodo = new Periodo();
            periodo.NumeroPeriodo=0;
            periodo.Articulo=art;
            periodo.Promedio=promedio;
            periodo.Prediccion=promedio;
            periodo.Demanda = promedio;            
            periodo.Actualizado = 1;
            periodo.CantDias = art.CantDias;
            DateTime fecha = DateTime.Today;
            fecha = fecha.AddDays(-art.CantDias);
            periodo.Fecha=fecha;    //el periodo creado registra datos historicos por lo que su fecha de creacion es anterior a la del 1º periodo real

            //periodo.Fecha = DateTime.Now;

            periodo.Error = new Error() { ErrorPromedio = errorPromedio, MSEn = MSEn, DesviacionEstandar=desviacionEstandar };
           // Fachada.getInstancia().guardar(periodo);
            GenerarPeriodo(periodo,art);
            //Fachada.getInstancia().cerrarSesion();
            art.Periodo.Add(periodo);
        }

        //Tendencia
        public void IniciarPeriodo(Articulo art, double promedio, double tend, double errorPromedio, double MSEn, double desviacionEstandar)
        {
            Periodo periodo = new Periodo();
            periodo.NumeroPeriodo=0;
            periodo.Articulo=art;
            periodo.Promedio=promedio;
            periodo.Tendencia = tend;
            periodo.Demanda =promedio;
            periodo.Actualizado = 1;
            periodo.Prediccion=promedio;
            periodo.CantDias=art.CantDias;
            DateTime fecha = DateTime.Today;
            fecha=fecha.AddDays(-art.CantDias);
            periodo.Fecha=fecha;    //el periodo creado registra datos histÃ³ricos por lo que su fecha de creacion es anterior a la del 1Âº periodo real

    
            periodo.Error = new Error() { ErrorPromedio = errorPromedio, MSEn = MSEn, DesviacionEstandar = desviacionEstandar };
            //Fachada.getInstancia().guardar(periodo);
            GenerarPeriodo(periodo,art);
            //Fachada.getInstancia().cerrarSesion();
            art.Periodo.Add(periodo);
        }





        /*
         *Actualizar periodos 
         */

        public void ActualizarPeriodo(Periodo perAct) {
        Periodo anterior = null;
        Exponencial exp;
        Articulo art = perAct.Articulo;
        int cantidad=0;
 
        anterior = Context.Periodo.Single(f=>f.NumeroPeriodo==perAct.NumeroPeriodo-1 && f.IdArticulo==art.Id);
        perAct.CantDias=art.CantDias;

        DateTime fechaInicioPeriodo = perAct.Fecha;
        DateTime fechaFinPeriodo = perAct.Fecha.AddDays(perAct.CantDias);
        List<ArticuloVenta> articuloVenta = Context.ArticuloVenta.Where(f => f.Venta.Fecha >= fechaInicioPeriodo && f.Venta.Fecha <= fechaFinPeriodo).ToList();
            if(articuloVenta.Count()>0)
                cantidad=articuloVenta.Sum(f => f.Cantidad);
        perAct.Demanda = cantidad;
        exp = FabricaExponencial.CrearExponencial(art.idSuavizamiento);
        exp.ActualizarPeriodo(anterior, perAct);
        perAct.Actualizado=1;

        //Fachada.getInstancia().modificar(perAct);
        GenerarPeriodo(perAct,art);

        //ExpPolitica expPolitica = new ExpPolitica(base.Context);

        //expPolitica.CalcularPolitica(art);
    }


        public string VerificarFinPeriodo() 
        {
        List<Periodo> resultado = new List<Periodo>();
        List<Periodo> aux =new List<Periodo>();
        
        DateTime temp = new DateTime();
        List<Articulo> articulosActualizados = new List<Articulo>();
        string devolucion ="";

   
        aux = Context.Periodo.Where(f => f.Actualizado == 0).ToList();

        for (int i = 0; i < aux.Count(); i++) {
            resultado.Add(aux.ElementAt(i));

            temp = new DateTime(resultado.ElementAt(i).Fecha.Year, resultado.ElementAt(i).Fecha.Month, resultado.ElementAt(i).Fecha.Day);
             temp=temp.AddDays(resultado.ElementAt(i).CantDias);

            if (temp.CompareTo(DateTime.Today) <= 0) {
              
                ActualizarPeriodo(resultado.ElementAt(i));
                articulosActualizados.Add(resultado.ElementAt(i).Articulo);
            }
        }

        Context.SaveChanges();

        if (articulosActualizados.Count() > 0) {
            ExpPolitica expPolitica = new ExpPolitica();
            devolucion = "Se actualizaron perí­odos de los siguientes artículos:";
            for (int i = 0; i < articulosActualizados.Count(); i++)
            {
                devolucion = devolucion + "\n   > " + articulosActualizados.ElementAt(i).Nombre;
                expPolitica.CalcularPolitica(articulosActualizados.ElementAt(i));
                Context.SaveChanges();
            }
        } else {
            devolucion = null;
        }

       // Fachada.getInstancia().cerrarSesion();
        
        return devolucion;
    }

        public string VerificarStockSR()
        {
            String devolucion = "";
            bool actualiza = false;
            DateTime fechaPolitica = DateTime.Now;

            List<Articulo> articulo = new List<Articulo>();

            articulo = Context.Articulo.Where(f => f.IdPolitica == 2).ToList(); // Politica 2 : SR

            for (int i = 0; i < articulo.Count(); i++)
            {
                fechaPolitica = new DateTime(articulo.ElementAt(i).UltimaActualizacion.Value.Year, articulo.ElementAt(i).UltimaActualizacion.Value.Month, articulo.ElementAt(i).UltimaActualizacion.Value.Day);

                if (articulo.ElementAt(i).ArticuloProveedor.Count == 0) return "";

                Proveedor proveedor = articulo.ElementAt(i).ArticuloProveedor.First().Proveedor;

                fechaPolitica = fechaPolitica.AddDays((double)proveedor.TiempoR);                
                
                if (fechaPolitica.CompareTo(DateTime.Now) <= 0) {
                    devolucion = "Los siguientes Artículos alcanzaron su fecha de pedido: <br>";
                    devolucion += "<br>" + articulo.ElementAt(i).Nombre;
                    actualiza = true;
                }

                devolucion = devolucion + "<br><br>Se recomienda reabastecer su stock. <br><br>";
            }
            if(!actualiza)            
                devolucion = "";
            
            return devolucion;            

    }
   
    }

}
